SVHN using SSD¶
In [1]:
import ipywidgets as widgets
import os
import sys
import skimage.io
import scipy
import json
In [2]:
lib_directory="C:\\Users\\Aashish\\Documents\\houseNumberOCR\\ssd_keras\\"
data_directory="C:\\Users\\Aashish\\Documents\\houseNumberOCR\\extra\\"
In [3]:
import cv2
from utils_ssd import *
import pandas as pd
from PIL import Image
from matplotlib import pyplot as plt
%matplotlib inline
%load_ext autoreload
%autoreload 2
In [4]:
LIBRARY_DIR = os.path.abspath(lib_directory)
sys.path.append(LIBRARY_DIR)
Convert the mat file to csv¶
In [5]:
def read_process_h5(filename):
f = h5py.File(filename, 'r')
groups = list(f['digitStruct'].items())
bbox_ds = np.array(groups[0][1]).squeeze()
names_ds = np.array(groups[1][1]).squeeze()
data_list = []
num_files = bbox_ds.shape[0]
count = 0
ds_size = 10000
for objref1, objref2 in zip(bbox_ds[:ds_size], names_ds[:ds_size]):
data_dict = {}
names_ds = np.array(f[objref2]).squeeze()
filename = ''.join(chr(x) for x in names_ds)
data_dict['filename'] = filename
items1 = list(f[objref1].items())
labels_ds = np.array(items1[1][1]).squeeze()
try:
label_vals = [int(f[ref][:][0, 0]) for ref in labels_ds]
except TypeError:
label_vals = [labels_ds]
data_dict['labels'] = label_vals
data_dict['length'] = len(label_vals)
height_ds = np.array(items1[0][1]).squeeze()
try:
height_vals = [f[ref][:][0, 0] for ref in height_ds]
except TypeError:
height_vals = [height_ds]
data_dict['height'] = height_vals
left_ds = np.array(items1[2][1]).squeeze()
try:
left_vals = [f[ref][:][0, 0] for ref in left_ds]
except TypeError:
left_vals = [left_ds]
data_dict['left'] = left_vals
top_ds = np.array(items1[3][1]).squeeze()
try:
top_vals = [f[ref][:][0, 0] for ref in top_ds]
except TypeError:
top_vals = [top_ds]
data_dict['top'] = top_vals
width_ds = np.array(items1[4][1]).squeeze()
try:
width_vals = [f[ref][:][0, 0] for ref in width_ds]
except TypeError:
width_vals = [width_ds]
data_dict['width'] = width_vals
data_list.append(data_dict)
count += 1
return data_list
def json_to_csv(json, filename):
pascal_list = []
for i in json:
for j in range(len(i['labels'])):
pascal_list.append({'class_id': int(i['labels'][j]), 'fname': i['filename']
,'xmin': int(i['left'][j]), 'xmax': int(i['left'][j]+i['width'][j])
,'ymin': int(i['top'][j]), 'ymax': int(i['top'][j]+i['height'][j])
})
df_pascal = pd.DataFrame(pascal_list,dtype='str')
df_pascal.to_csv(filename,index=False)
In [6]:
file_path = data_directory+'/digitStruct.mat'
p = read_process_h5(file_path)
json_to_csv(p, data_directory+'/data.csv')
In [7]:
task = 'svhn'
labels_path = f'{data_directory}data.csv'
input_format = ['class_id','image_name','xmin','xmax','ymin','ymax' ]
df = pd.read_csv(labels_path)
Boxing check using random image¶
In [8]:
def view_random(df):
file = np.random.choice(df.fname)
im = skimage.io.imread(f'{data_directory}/{file}')
annots = df[df.fname==file].iterrows()
plt.figure(figsize=(6,6))
plt.imshow(im)
current_axis = plt.gca()
for box in annots:
label = box[1]['class_id']
current_axis.add_patch(plt.Rectangle(
(box[1]['xmin'], box[1]['ymin']), box[1]['xmax']-box[1]['xmin'],
box[1]['ymax']-box[1]['ymin'], color='blue', fill=False, linewidth=2))
current_axis.text(box[1]['xmin'], box[1]['ymin'], label, size='x-large', color='white', bbox={'facecolor':'blue', 'alpha':1.0})
plt.show()
In [9]:
view_random(df)
Set Configurations¶
In [10]:
class Configuration(Config):
batch_size = 8
dataset_folder = data_directory
task = task
labels_path = labels_path
input_format = input_format
conf=Configuration()
resize = Resize(height=conf.img_height, width=conf.img_width)
trans = [resize]
In [11]:
learner = SSD_finetune(conf)
learner.get_data(create_subset=True)
weights_destination_path=learner.init_weights()
learner.get_model(mode='training', weights_path = weights_destination_path)
model = learner.model
learner.get_input_encoder()
ssd_input_encoder = learner.ssd_input_encoder
In [12]:
train_annotation_file=f'{conf.dataset_folder}train_data.csv'
val_annotation_file=f'{conf.dataset_folder}validation_data.csv'
test_annotation_file=f'{conf.dataset_folder}test_data.csv'
Divide data into train and validation (train - 6670 images, Validation - 1665 images)¶
In [13]:
train_generator = learner.get_generator(conf.batch_size, trans=trans, anot_file=train_annotation_file,
encoder=ssd_input_encoder)
val_generator = learner.get_generator(conf.batch_size, trans=trans, anot_file=val_annotation_file,
encoder=ssd_input_encoder,val=True)
Training dataset¶
In [14]:
learner.init_training()
In [15]:
histroy = learner.train(train_generator, val_generator, steps=100,epochs=60)
In [16]:
from eval_utils.average_precision_evaluator import Evaluator
Evaluate for one image¶
In [17]:
print(learner.classes)
class_count = 10
test_dataset = learner.prepare_ds(conf.dataset_folder, test_annotation_file)
test_generator = learner.get_generator(conf.batch_size, trans=trans, anot_file=test_annotation_file,
encoder=ssd_input_encoder)
imgs,gt = next(test_generator)
y_pred = learner.model.predict(np.expand_dims(imgs[0],0))
from ssd_encoder_decoder.ssd_output_decoder import decode_detections, decode_detections_fast
y_pred_decoded = decode_detections(y_pred,
confidence_thresh=0.5,
iou_threshold=0.45,
top_k=200,
input_coords='centroids',
normalize_coords=True,
img_height=conf.img_height,
img_width=conf.img_width)
plt.figure(figsize=(6,6))
plt.imshow(imgs[0])
print(y_pred_decoded[0])
current_axis = plt.gca()
for box in y_pred_decoded[0]:
class_id = box[0]
confidence = box[1]
xmin,ymin,xmax,ymax = box[2],box[3],box[4],box[5]
label = '{}: {:.2f}'.format(learner.id2digit[class_id], confidence)
current_axis.add_patch(plt.Rectangle((xmin, ymin), xmax-xmin, ymax-ymin, color='blue', fill=False, linewidth=2))
current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={'facecolor':'blue', 'alpha':1.0})
plt.show()
Evaluate for a test dataset (1665 images)¶
In [18]:
ev = Evaluator(learner.model,class_count, test_dataset,model_mode='training' )
meanAveragePrecision=ev(300,300,1,data_generator_mode='resize')
print()
print("Mean Average Precision",meanAveragePrecision)
In [ ]: